using System;
using System.Collections.Generic;
using UnityEngine;
using ItemStatsSystem;

namespace CustomItemLib
{
    // 自定义物品注册表（单例模式）
    // 负责管理自定义物品的注册和清理
    public class CustomItemRegistry
    {
        #region 单例
        
        private static CustomItemRegistry? instance;
        private static readonly object lockObject = new object();
        
        // 获取单例实例
        public static CustomItemRegistry Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (lockObject)
                    {
                        if (instance == null)
                        {
                            instance = new CustomItemRegistry();
                            Debug.Log("[CustomItemLib] CustomItemRegistry 单例已创建");
                        }
                    }
                }
                return instance;
            }
        }
        
        // 私有构造函数，防止外部实例化
        private CustomItemRegistry()
        {
            registeredItems = new Dictionary<int, Item>();
        }
        
        #endregion
        
        #region 字段
        
        // 存储已注册的自定义物品，键为 TypeID，值为 Item 实例
        private readonly Dictionary<int, Item> registeredItems;
        
        #endregion
        
        #region 属性
        
        // 已注册物品的数量
        public int RegisteredItemsCount => registeredItems.Count;
        
        // 是否已初始化
        public bool IsInitialized { get; private set; }
        
        #endregion
        
        #region 生命周期方法
        
        // 初始化注册表（确保内容为空）
        public void Initialize()
        {
            if (IsInitialized)
            {
                Debug.LogWarning("[CustomItemLib] 注册表已初始化，将先清理现有内容");
                Uninitialize();
            }
            
            registeredItems.Clear();
            IsInitialized = true;
            Debug.Log("[CustomItemLib] 注册表已初始化");
        }
        
        // 销毁注册表（移除所有物品数据）
        public void Uninitialize()
        {
            if (!IsInitialized)
            {
                Debug.LogWarning("[CustomItemLib] 注册表未初始化，无需销毁");
                return;
            }
            
            UnregisterAll();
            IsInitialized = false;
            Debug.Log("[CustomItemLib] 注册表已销毁");
        }
        
        #endregion
        
        #region 单个物品操作
        
        // 注册单个自定义物品
        public bool Register(CustomItemData itemData)
        {
            if (itemData == null)
            {
                Debug.LogError("[CustomItemLib] 物品数据为空");
                return false;
            }
            
            // 检查是否已注册
            if (registeredItems.ContainsKey(itemData.NewTypeID))
            {
                Debug.LogWarning($"[CustomItemLib] 物品已注册: {itemData.DisplayName} (TypeID: {itemData.NewTypeID})");
                return false;
            }
            
            // 创建自定义物品实例
            Item? item = CustomItemFactory.CreateCustomItem(itemData);
            if (item == null)
            {
                Debug.LogError($"[CustomItemLib] 创建物品失败: {itemData.DisplayName}");
                return false;
            }
            
            // 注册物品到游戏系统
            bool success = ItemAssetsCollection.AddDynamicEntry(item);
            
            if (success)
            {
                // 注册成功，添加到本地字典
                registeredItems[itemData.NewTypeID] = item;
                Debug.Log($"[CustomItemLib] ✓ 成功注册: {itemData.DisplayName} (TypeID: {itemData.NewTypeID})");
            }
            else
            {
                Debug.LogWarning($"[CustomItemLib] ✗ 注册失败: {itemData.DisplayName} (TypeID: {itemData.NewTypeID})");
            }
            
            return success;
        }
        
        // 取消注册单个自定义物品
        public bool Unregister(int typeID)
        {
            if (!registeredItems.TryGetValue(typeID, out Item? item))
            {
                Debug.LogWarning($"[CustomItemLib] 未找到已注册的物品 (TypeID: {typeID})");
                return false;
            }
            
            try
            {
                ItemAssetsCollection.RemoveDynamicEntry(item);
                registeredItems.Remove(typeID);
                Debug.Log($"[CustomItemLib] ✓ 成功取消注册: {item.DisplayName} (TypeID: {typeID})");
                return true;
            }
            catch (Exception ex)
            {
                Debug.LogError($"[CustomItemLib] ✗ 取消注册失败: {item.DisplayName} (TypeID: {typeID})\n{ex.Message}");
                return false;
            }
        }
        
        // 取消注册单个自定义物品（通过物品数据）
        public bool Unregister(CustomItemData itemData)
        {
            if (itemData == null)
            {
                Debug.LogError("[CustomItemLib] 物品数据为空");
                return false;
            }
            
            return Unregister(itemData.NewTypeID);
        }
        
        #endregion
        
        #region 批量操作
        
        // 批量注册自定义物品
        public int RegisterBatch(CustomItemData[] items)
        {
            if (items == null || items.Length == 0)
            {
                Debug.LogWarning("[CustomItemLib] 物品数据数组为空，跳过批量注册");
                return 0;
            }
            
            Debug.Log($"[CustomItemLib] 开始批量注册 {items.Length} 个物品");
            
            int successCount = 0;
            int failureCount = 0;
            
            foreach (var itemData in items)
            {
                try
                {
                    if (Register(itemData))
                        successCount++;
                    else
                        failureCount++;
                }
                catch (Exception ex)
                {
                    failureCount++;
                    Debug.LogError($"[CustomItemLib] 注册 {itemData.DisplayName} 时出错: {ex.Message}\n{ex.StackTrace}");
                }
            }
            
            Debug.Log($"[CustomItemLib] 批量注册完成: 成功 {successCount} 个，失败 {failureCount} 个，当前共 {registeredItems.Count} 个");
            return successCount;
        }
        
        // 批量取消注册自定义物品
        public int UnregisterBatch(int[] typeIDs)
        {
            if (typeIDs == null || typeIDs.Length == 0)
            {
                Debug.LogWarning("[CustomItemLib] TypeID 数组为空，跳过批量取消注册");
                return 0;
            }
            
            Debug.Log($"[CustomItemLib] 开始批量取消注册 {typeIDs.Length} 个物品");
            
            int successCount = 0;
            int failureCount = 0;
            
            foreach (var typeID in typeIDs)
            {
                if (Unregister(typeID))
                    successCount++;
                else
                    failureCount++;
            }
            
            Debug.Log($"[CustomItemLib] 批量取消注册完成: 成功 {successCount} 个，失败 {failureCount} 个，剩余 {registeredItems.Count} 个");
            return successCount;
        }
        
        // 批量取消注册自定义物品（通过物品数据）
        public int UnregisterBatch(CustomItemData[] items)
        {
            if (items == null || items.Length == 0)
            {
                Debug.LogWarning("[CustomItemLib] 物品数据数组为空，跳过批量取消注册");
                return 0;
            }
            
            int[] typeIDs = new int[items.Length];
            for (int i = 0; i < items.Length; i++)
            {
                typeIDs[i] = items[i].NewTypeID;
            }
            
            return UnregisterBatch(typeIDs);
        }
        
        // 取消注册所有物品
        public int UnregisterAll()
        {
            if (registeredItems.Count == 0)
            {
                Debug.Log("[CustomItemLib] 没有需要清理的物品");
                return 0;
            }
            
            Debug.Log($"[CustomItemLib] 开始清理所有 {registeredItems.Count} 个已注册物品");
            
            int successCount = 0;
            int failureCount = 0;
            
            // 复制键集合以避免在迭代时修改字典
            var typeIDs = new List<int>(registeredItems.Keys);
            
            foreach (var typeID in typeIDs)
            {
                if (Unregister(typeID))
                    successCount++;
                else
                    failureCount++;
            }
            
            Debug.Log($"[CustomItemLib] 清理完成: 成功 {successCount} 个，失败 {failureCount} 个");
            return successCount;
        }
        
        #endregion
        
        #region 查询方法
        
        // 检查物品是否已注册
        public bool IsRegistered(int typeID)
        {
            return registeredItems.ContainsKey(typeID);
        }
        
        // 检查物品是否已注册
        public bool IsRegistered(CustomItemData itemData)
        {
            if (itemData == null)
                return false;
            
            return IsRegistered(itemData.NewTypeID);
        }
        
        // 获取已注册的物品实例
        public Item? GetRegisteredItem(int typeID)
        {
            return registeredItems.TryGetValue(typeID, out Item? item) ? item : null;
        }
        
        #endregion
    }
}